home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Freeware / Adobe Air 1.5 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / containers / Grid.as < prev    next >
Encoding:
Text File  |  2008-10-29  |  12.2 KB  |  397 lines
  1. package mx.containers
  2. {
  3.    import mx.containers.gridClasses.GridColumnInfo;
  4.    import mx.containers.gridClasses.GridRowInfo;
  5.    import mx.core.EdgeMetrics;
  6.    import mx.core.mx_internal;
  7.    
  8.    use namespace mx_internal;
  9.    
  10.    public class Grid extends Box
  11.    {
  12.       mx_internal static const VERSION:String = "3.0.0.0";
  13.       
  14.       private var columnWidths:Array;
  15.       
  16.       private var rowHeights:Array;
  17.       
  18.       private var needToRemeasure:Boolean = true;
  19.       
  20.       public function Grid()
  21.       {
  22.          super();
  23.       }
  24.       
  25.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  26.       {
  27.          var _loc4_:int = 0;
  28.          var _loc5_:GridRow = null;
  29.          if(needToRemeasure)
  30.          {
  31.             measure();
  32.          }
  33.          super.updateDisplayList(param1,param2);
  34.          var _loc3_:int = 0;
  35.          var _loc6_:Array = [];
  36.          var _loc7_:int = 0;
  37.          while(_loc7_ < numChildren)
  38.          {
  39.             _loc5_ = GridRow(getChildAt(_loc7_));
  40.             if(_loc5_.includeInLayout)
  41.             {
  42.                _loc6_.push(_loc5_);
  43.                _loc3_++;
  44.             }
  45.             _loc7_++;
  46.          }
  47.          _loc4_ = 0;
  48.          while(_loc4_ < _loc3_)
  49.          {
  50.             _loc5_ = _loc6_[_loc4_];
  51.             rowHeights[_loc4_].y = _loc5_.y;
  52.             rowHeights[_loc4_].height = _loc5_.height;
  53.             _loc4_++;
  54.          }
  55.          _loc4_ = 0;
  56.          while(_loc4_ < _loc3_)
  57.          {
  58.             _loc5_ = _loc6_[_loc4_];
  59.             _loc5_.doRowLayout(_loc5_.width * _loc5_.scaleX,_loc5_.height * _loc5_.scaleY);
  60.             _loc4_++;
  61.          }
  62.       }
  63.       
  64.       private function distributeItemWidth(param1:GridItem, param2:int, param3:Number, param4:Array) : void
  65.       {
  66.          var _loc12_:int = 0;
  67.          var _loc13_:GridColumnInfo = null;
  68.          var _loc14_:Number = NaN;
  69.          var _loc15_:Number = NaN;
  70.          var _loc5_:Number = param1.maxWidth;
  71.          var _loc6_:Number = param1.getExplicitOrMeasuredWidth();
  72.          var _loc7_:Number = param1.minWidth;
  73.          var _loc8_:int = param1.colSpan;
  74.          var _loc9_:Number = param1.percentWidth;
  75.          var _loc10_:Number = 0;
  76.          var _loc11_:Boolean = false;
  77.          _loc12_ = param2;
  78.          while(_loc12_ < param2 + _loc8_)
  79.          {
  80.             _loc13_ = param4[_loc12_];
  81.             _loc6_ -= _loc13_.preferred;
  82.             _loc7_ -= _loc13_.min;
  83.             _loc10_ += _loc13_.flex;
  84.             _loc12_++;
  85.          }
  86.          if(_loc8_ > 1)
  87.          {
  88.             _loc14_ = param3 * (_loc8_ - 1);
  89.             _loc6_ -= _loc14_;
  90.             _loc7_ -= _loc14_;
  91.          }
  92.          if(_loc10_ == 0)
  93.          {
  94.             _loc10_ = _loc8_;
  95.             _loc11_ = true;
  96.          }
  97.          _loc6_ = _loc6_ > 0 ? Math.ceil(_loc6_ / _loc10_) : 0;
  98.          _loc7_ = _loc7_ > 0 ? Math.ceil(_loc7_ / _loc10_) : 0;
  99.          _loc12_ = param2;
  100.          while(_loc12_ < param2 + _loc8_)
  101.          {
  102.             _loc13_ = param4[_loc12_];
  103.             _loc15_ = _loc11_ ? 1 : _loc13_.flex;
  104.             _loc13_.preferred += _loc6_ * _loc15_;
  105.             _loc13_.min += _loc7_ * _loc15_;
  106.             if(_loc9_)
  107.             {
  108.                _loc13_.percent = Math.max(_loc13_.percent,_loc9_ / _loc8_);
  109.             }
  110.             _loc12_++;
  111.          }
  112.          if(_loc8_ == 1 && _loc5_ < _loc13_.max)
  113.          {
  114.             _loc13_.max = _loc5_;
  115.          }
  116.       }
  117.       
  118.       private function distributeItemHeight(param1:GridItem, param2:Number, param3:Number, param4:Array) : void
  119.       {
  120.          var _loc11_:int = 0;
  121.          var _loc12_:GridRowInfo = null;
  122.          var _loc13_:Number = NaN;
  123.          var _loc14_:Number = NaN;
  124.          var _loc5_:Number = param1.maxHeight;
  125.          var _loc6_:Number = param1.getExplicitOrMeasuredHeight();
  126.          var _loc7_:Number = param1.minHeight;
  127.          var _loc8_:int = param1.rowSpan;
  128.          var _loc9_:Number = 0;
  129.          var _loc10_:Boolean = false;
  130.          _loc11_ = param2;
  131.          while(_loc11_ < param2 + _loc8_)
  132.          {
  133.             _loc12_ = param4[_loc11_];
  134.             _loc6_ -= _loc12_.preferred;
  135.             _loc7_ -= _loc12_.min;
  136.             _loc9_ += _loc12_.flex;
  137.             _loc11_++;
  138.          }
  139.          if(_loc8_ > 1)
  140.          {
  141.             _loc13_ = param3 * (_loc8_ - 1);
  142.             _loc6_ -= _loc13_;
  143.             _loc7_ -= _loc13_;
  144.          }
  145.          if(_loc9_ == 0)
  146.          {
  147.             _loc9_ = _loc8_;
  148.             _loc10_ = true;
  149.          }
  150.          _loc6_ = _loc6_ > 0 ? Math.ceil(_loc6_ / _loc9_) : 0;
  151.          _loc7_ = _loc7_ > 0 ? Math.ceil(_loc7_ / _loc9_) : 0;
  152.          _loc11_ = param2;
  153.          while(_loc11_ < param2 + _loc8_)
  154.          {
  155.             _loc12_ = param4[_loc11_];
  156.             _loc14_ = _loc10_ ? 1 : _loc12_.flex;
  157.             _loc12_.preferred += _loc6_ * _loc14_;
  158.             _loc12_.min += _loc7_ * _loc14_;
  159.             _loc11_++;
  160.          }
  161.          if(_loc8_ == 1 && _loc5_ < _loc12_.max)
  162.          {
  163.             _loc12_.max = _loc5_;
  164.          }
  165.       }
  166.       
  167.       override public function invalidateSize() : void
  168.       {
  169.          if(!isNaN(explicitWidth) && !isNaN(explicitHeight))
  170.          {
  171.             needToRemeasure = true;
  172.          }
  173.          super.invalidateSize();
  174.       }
  175.       
  176.       override protected function measure() : void
  177.       {
  178.          var _loc4_:GridRow = null;
  179.          var _loc5_:GridItem = null;
  180.          var _loc6_:int = 0;
  181.          var _loc7_:int = 0;
  182.          var _loc8_:int = 0;
  183.          var _loc12_:int = 0;
  184.          var _loc19_:Number = NaN;
  185.          var _loc22_:GridRow = null;
  186.          var _loc23_:EdgeMetrics = null;
  187.          var _loc25_:int = 0;
  188.          var _loc26_:int = 0;
  189.          var _loc27_:int = 0;
  190.          var _loc28_:* = undefined;
  191.          var _loc29_:* = undefined;
  192.          var _loc30_:GridRowInfo = null;
  193.          var _loc31_:GridColumnInfo = null;
  194.          var _loc32_:Number = NaN;
  195.          var _loc1_:int = 0;
  196.          var _loc2_:int = 0;
  197.          var _loc3_:Array = [];
  198.          var _loc9_:Array = [];
  199.          var _loc10_:int = 0;
  200.          while(_loc10_ < numChildren)
  201.          {
  202.             _loc4_ = GridRow(getChildAt(_loc10_));
  203.             if(_loc4_.includeInLayout)
  204.             {
  205.                _loc9_.push(_loc4_);
  206.                _loc1_++;
  207.             }
  208.             _loc10_++;
  209.          }
  210.          _loc6_ = 0;
  211.          while(_loc6_ < _loc1_)
  212.          {
  213.             _loc8_ = 0;
  214.             _loc4_ = _loc9_[_loc6_];
  215.             _loc4_.numGridItems = _loc4_.numChildren;
  216.             _loc4_.rowIndex = _loc6_;
  217.             _loc7_ = 0;
  218.             while(_loc7_ < _loc4_.numGridItems)
  219.             {
  220.                if(_loc6_ > 0)
  221.                {
  222.                   _loc25_ = int(_loc3_[_loc8_]);
  223.                   while(!isNaN(_loc25_) && _loc25_ >= _loc6_)
  224.                   {
  225.                      _loc8_++;
  226.                      _loc25_ = int(_loc3_[_loc8_]);
  227.                   }
  228.                }
  229.                _loc5_ = GridItem(_loc4_.getChildAt(_loc7_));
  230.                _loc5_.colIndex = _loc8_;
  231.                if(_loc5_.rowSpan > 1)
  232.                {
  233.                   _loc26_ = _loc6_ + _loc5_.rowSpan - 1;
  234.                   _loc27_ = 0;
  235.                   while(_loc27_ < _loc5_.colSpan)
  236.                   {
  237.                      _loc3_[_loc8_ + _loc27_] = _loc26_;
  238.                      _loc27_++;
  239.                   }
  240.                }
  241.                _loc8_ += _loc5_.colSpan;
  242.                _loc7_++;
  243.             }
  244.             if(_loc8_ > _loc2_)
  245.             {
  246.                _loc2_ = _loc8_;
  247.             }
  248.             _loc6_++;
  249.          }
  250.          rowHeights = new Array(_loc1_);
  251.          columnWidths = new Array(_loc2_);
  252.          _loc6_ = 0;
  253.          while(_loc6_ < _loc1_)
  254.          {
  255.             rowHeights[_loc6_] = new GridRowInfo();
  256.             _loc6_++;
  257.          }
  258.          _loc6_ = 0;
  259.          while(_loc6_ < _loc2_)
  260.          {
  261.             columnWidths[_loc6_] = new GridColumnInfo();
  262.             _loc6_++;
  263.          }
  264.          var _loc11_:int = int.MAX_VALUE;
  265.          var _loc13_:int = 1;
  266.          var _loc14_:Number = getStyle("horizontalGap");
  267.          var _loc15_:Number = getStyle("verticalGap");
  268.          do
  269.          {
  270.             _loc12_ = _loc13_;
  271.             _loc13_ = _loc11_;
  272.             _loc6_ = 0;
  273.             while(_loc6_ < _loc1_)
  274.             {
  275.                _loc4_ = _loc9_[_loc6_];
  276.                _loc4_.columnWidths = columnWidths;
  277.                _loc4_.rowHeights = rowHeights;
  278.                _loc7_ = 0;
  279.                while(_loc7_ < _loc4_.numGridItems)
  280.                {
  281.                   _loc5_ = GridItem(_loc4_.getChildAt(_loc7_));
  282.                   _loc28_ = _loc5_.rowSpan;
  283.                   _loc29_ = _loc5_.colSpan;
  284.                   if(_loc28_ == _loc12_)
  285.                   {
  286.                      distributeItemHeight(_loc5_,_loc6_,_loc15_,rowHeights);
  287.                   }
  288.                   else if(_loc28_ > _loc12_ && _loc28_ < _loc13_)
  289.                   {
  290.                      _loc13_ = _loc28_;
  291.                   }
  292.                   if(_loc29_ == _loc12_)
  293.                   {
  294.                      distributeItemWidth(_loc5_,_loc5_.colIndex,_loc14_,columnWidths);
  295.                   }
  296.                   else if(_loc29_ > _loc12_ && _loc29_ < _loc13_)
  297.                   {
  298.                      _loc13_ = _loc29_;
  299.                   }
  300.                   _loc7_++;
  301.                }
  302.                _loc6_++;
  303.             }
  304.          }
  305.          while(_loc13_ < _loc11_);
  306.          
  307.          var _loc16_:Number = 0;
  308.          var _loc17_:Number = 0;
  309.          var _loc18_:Number = 0;
  310.          _loc19_ = 0;
  311.          _loc6_ = 0;
  312.          while(_loc6_ < _loc1_)
  313.          {
  314.             _loc30_ = rowHeights[_loc6_];
  315.             if(_loc30_.min > _loc30_.preferred)
  316.             {
  317.                _loc30_.min = _loc30_.preferred;
  318.             }
  319.             if(_loc30_.max < _loc30_.preferred)
  320.             {
  321.                _loc30_.max = _loc30_.preferred;
  322.             }
  323.             _loc17_ += _loc30_.min;
  324.             _loc19_ += _loc30_.preferred;
  325.             _loc6_++;
  326.          }
  327.          _loc6_ = 0;
  328.          while(_loc6_ < _loc2_)
  329.          {
  330.             _loc31_ = columnWidths[_loc6_];
  331.             if(_loc31_.min > _loc31_.preferred)
  332.             {
  333.                _loc31_.min = _loc31_.preferred;
  334.             }
  335.             if(_loc31_.max < _loc31_.preferred)
  336.             {
  337.                _loc31_.max = _loc31_.preferred;
  338.             }
  339.             _loc16_ += _loc31_.min;
  340.             _loc18_ += _loc31_.preferred;
  341.             _loc6_++;
  342.          }
  343.          var _loc20_:EdgeMetrics = viewMetricsAndPadding;
  344.          var _loc21_:Number = _loc20_.left + _loc20_.right;
  345.          var _loc24_:Number = 0;
  346.          if(_loc2_ > 1)
  347.          {
  348.             _loc21_ += getStyle("horizontalGap") * (_loc2_ - 1);
  349.          }
  350.          _loc6_ = 0;
  351.          while(_loc6_ < _loc1_)
  352.          {
  353.             _loc22_ = _loc9_[_loc6_];
  354.             _loc23_ = _loc22_.viewMetricsAndPadding;
  355.             _loc32_ = _loc23_.left + _loc23_.right;
  356.             if(_loc32_ > _loc24_)
  357.             {
  358.                _loc24_ = _loc32_;
  359.             }
  360.             _loc6_++;
  361.          }
  362.          _loc21_ += _loc24_;
  363.          _loc16_ += _loc21_;
  364.          _loc18_ += _loc21_;
  365.          _loc21_ = _loc20_.top + _loc20_.bottom;
  366.          if(_loc1_ > 1)
  367.          {
  368.             _loc21_ += getStyle("verticalGap") * (_loc1_ - 1);
  369.          }
  370.          _loc6_ = 0;
  371.          while(_loc6_ < _loc1_)
  372.          {
  373.             _loc22_ = _loc9_[_loc6_];
  374.             _loc23_ = _loc22_.viewMetricsAndPadding;
  375.             _loc21_ += _loc23_.top + _loc23_.bottom;
  376.             _loc6_++;
  377.          }
  378.          _loc17_ += _loc21_;
  379.          _loc19_ += _loc21_;
  380.          _loc6_ = 0;
  381.          while(_loc6_ < _loc1_)
  382.          {
  383.             _loc22_ = _loc9_[_loc6_];
  384.             _loc22_.updateRowMeasurements();
  385.             _loc6_++;
  386.          }
  387.          super.measure();
  388.          measuredMinWidth = Math.max(measuredMinWidth,_loc16_);
  389.          measuredMinHeight = Math.max(measuredMinHeight,_loc17_);
  390.          measuredWidth = Math.max(measuredWidth,_loc18_);
  391.          measuredHeight = Math.max(measuredHeight,_loc19_);
  392.          needToRemeasure = false;
  393.       }
  394.    }
  395. }
  396.  
  397.